// Copyright (C) 2023 即时通讯网(52im.net) & Jack Jiang.
// The RainbowChat Project. All rights reserved.
// 
// 【本产品为著作权产品，合法授权后请放心使用，禁止外传！】
// 【本次授权给：<北京小羊驼科技有限公司>，授权编号：<NT231212144350>，代码指纹：<A.702363430.550>，技术对接人微信：<ID: wxid_wbyootvkdcgj22>】
// 【授权寄送：<收件：苏先生、地址：北京市大兴区北京密码西区6号楼1单元301、电话：18613885610、邮箱：bd@huiyuanxiang-inc.com>】
// 
// 【本系列产品在国家版权局的著作权登记信息如下】：
// 1）国家版权局登记名(简称)和权证号：RainbowChat    （证书号：软著登字第1220494号、登记号：2016SR041877）
// 2）国家版权局登记名(简称)和权证号：RainbowChat-Web（证书号：软著登字第3743440号、登记号：2019SR0322683）
// 3）国家版权局登记名(简称)和权证号：RainbowAV      （证书号：软著登字第2262004号、登记号：2017SR676720）
// 4）国家版权局登记名(简称)和权证号：MobileIMSDK-Web（证书号：软著登字第2262073号、登记号：2017SR676789）
// 5）国家版权局登记名(简称)和权证号：MobileIMSDK    （证书号：软著登字第1220581号、登记号：2016SR041964）
// * 著作权所有人：江顺/苏州网际时代信息科技有限公司
// 
// 【违法或违规使用投诉和举报方式】：
// 联系邮件：jack.jiang@52im.net
// 联系微信：hellojackjiang
// 联系QQ号：413980957
// 授权说明：http://www.52im.net/thread-1115-1-1.html
// 官方社区：http://www.52im.net
package com.x52im.mall;

import android.app.Activity;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.Gallery;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;

import com.alibaba.fastjson.JSON;
import com.eva.android.widget.AListAdapter2;
import com.eva.android.widget.AsyncBitmapLoader;
import com.eva.android.widget.BaseFragment;
import com.eva.framework.dto.DataFromClient;
import com.eva.framework.dto.DataFromServer;
import com.eva.framework.dto.SysActionConst;
import com.x52im.mall.dto.CommonProcessorConst;
import com.x52im.mall.logic.score.DBAdapter;
import com.x52im.mall.logic.shop.GoodDetailActivity;
import com.x52im.mall.logic.shop.GoodsProvider;
import com.x52im.mall.logic.shop.IndicationDotList;
import com.x52im.mall.score.dto.TokenRechangeHistory;
import com.x52im.mall.shop.dto.Device;
import com.x52im.mall.shop.dto.Feature;
import com.x52im.mall.shop.dto.SO;
import com.x52im.rbchat.MyApplication;
import com.x52im.rbchat.R;

import java.util.ArrayList;
import java.util.Timer;
import java.util.TimerTask;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

// TODO: 商城模块已多年未维护，当前仅用于演示目的，将在下一版本删除所有相关代码，建议如用不到，可立即移除！
@Deprecated
public class MainFragment extends BaseFragment {

    private final static String TAG = MainFragment.class.getSimpleName();

//    /** Intent request codes: 从充值Activity的回调请求码常量 */
//    public final static int REQUEST_TO_RECHARGEACTIVITY = 1;

    /** 积分相关操作包装实现类 */
    private ScoreOperationWrapper scoreOperationWrapper = null;
    /** 购物相关操作包装实现类 */
    private ShopOperationWrapper shopOperationWrapper = null;

    private DBAdapter mDBAdapter;

    @Override
    public void onDestroyView() {
        scoreOperationWrapper = null;
        shopOperationWrapper = null;
        super.onDestroyView();
    }

    /**
     * 本方法由父类的 {@link #onCreateView(LayoutInflater, ViewGroup, Bundle)} 调用，子类可在此方法中实现ui的初始化。
     *
     * @see #onCreateView(LayoutInflater, ViewGroup, Bundle)
     */
    @Override
    protected View initViews(@NonNull LayoutInflater inflater, @Nullable ViewGroup container) {
        View view = inflater.inflate(R.layout.common_mall_main_fragment, container, false);

        scoreOperationWrapper = new ScoreOperationWrapper();
        shopOperationWrapper = new ShopOperationWrapper(view);

        return view;
    }

    //	/**
//	 * 处理回调.
//	 * {@inheritDoc}
//	 */
//  @Override
//	public void onActivityResult(int requestCode, int resultCode, Intent data)
//	{
//		// 处理充值完成的回调
//		switch (requestCode)
//		{
//			// 从“开始充值”Activity中回调时
//			case REQUEST_TO_RECHARGEACTIVITY:
//			{
//				// When DeviceListActivity returns with a device to connect
//				if (resultCode == Activity.RESULT_OK)
//				{
//					// 异步刷该用户当前的积分数
//					scoreOperationWrapper.refreshCurrentTokenCountAsync();
//				}
//				break;
//			}
//		}
//	}

    // -----------------------------------------------------------------------------------------
    // inner class
    /**
     * 积分相关操作包装实现类.
     */
    private class ScoreOperationWrapper
    {
        /** 按钮：进行充值 */
        private Button btnGoToChongZhi = null;

        public ScoreOperationWrapper()
        {
            Timer mTimer = new Timer();
            mTimer.schedule(new TimerTask() {
                @Override
                public void run() {
                    mDBAdapter = new DBAdapter(MyApplication.getInstance2());
                    mDBAdapter.open();
                    Cursor cursor = null;
                    try {
                        cursor = mDBAdapter.getAll();
//                        System.out.println("[LZ]============ 本地数据库遗留数据数量：" + cursor.getCount());// TODO
                        cursor.moveToFirst();
                        for (int i = 0; i < cursor.getCount(); i++)
                        {
                            String keyId = cursor.getString(cursor.getColumnIndex(DBAdapter.KEY_ID));
                            String jsonStr = cursor.getString(cursor.getColumnIndex(DBAdapter.CONTENT));
                            String clsName = cursor.getString(cursor.getColumnIndex(DBAdapter.CLS_NAME));
                            new CommonDataAsync(a())
                            {
                                @Override
                                protected DataFromClient forDoInBackground(String param, String clsName)
                                {
                                    if(clsName.equals(TokenRechangeHistory.class.getCanonicalName())){
                                        return DataFromClient.n().setProcessorId(CommonProcessorConst.PROCESSOR_SCORE)
                                                .setJobDispatchId(com.x52im.mall.score.dto.JobDispatchConst.SCORE_RECHARGE_ETC)
                                                .setActionId(SysActionConst.ACTION_NEW)
                                                .setNewData(JSON.parseObject(param, TokenRechangeHistory.class));
                                    }
                                    else if(clsName.equals(SO.class.getCanonicalName()))
                                    {
                                        return DataFromClient.n().setProcessorId(CommonProcessorConst.PROCESSOR_SHOP_NEED$AUTHED)
                                                .setJobDispatchId(com.x52im.mall.shop.dto.JobDispatchConst.SHOP_GOODS_MGR_NEED$AUTHED)
                                                .setActionId(SysActionConst.ACTION_EDIT)
                                                .setNewData(JSON.parseObject(param, SO.class));
                                    }
                                    return null;
                                }

                                @Override
                                protected void forOnPostExecute(DataFromServer dfs, String keyId) {
                                    Log.v("TAG", "定时器服务端返回数据:");

                                    // 服务端的返回值对象
                                    if (dfs != null && dfs.isSuccess())
                                    {
                                        mDBAdapter = new DBAdapter(MyApplication.getInstance2());
                                        mDBAdapter.open();
                                        System.out.println("=======打开");
                                        mDBAdapter.delete(keyId);
                                        System.out.println("======剩余 count : " + mDBAdapter.getAll().getCount());
                                        mDBAdapter.close();
                                        System.out.println("=======关闭");
                                    }

                                }

                            }.execute(new String[] { keyId, jsonStr, clsName });

                            cursor.moveToNext();
                        }
                    }
                    catch (Exception e) {
                        Log.w(TAG, e);
                    }
                    finally {
                        if (cursor != null)
                            cursor.close();
                        mDBAdapter.close();
//                        System.out.println("=========定时器结束！");// TODO
                    }
                }

            }, 5 * 1000, 30 * 1000);

            // 异步刷该用户当前的积分数
//			new RefreshCurrentTokenCountAsync(MainActivity.this).execute();
        }
    }

    /**
     * 购物相关操作包装实现类.
     */
    private class ShopOperationWrapper
    {
        /** 复合组件：无穷进度提示 */
        private LinearLayout layoutInfiniteProgessBar = null;
        private ListView gridview = null;
        private DefaultListAdapter listAdapter = null;

        /** 列表的全局数据结构对对象 */
        private ArrayList<Device> staticListData = null;
        private ArrayList<Feature> features = null;

        /** 画廊（用于显示对应颜色的各图片）  */
        private Gallery galeryPics = null;
        private IndicationDotList mDotList = null;

        //** 各UI所对应的数据模型
        /** 画廊Adapter（数据模型与当前选中的颜色所相关的图片数据模型对应） */
        private PicsGalleryAdapter galleryAdapter = null;

        private View parentView = null;

        public ShopOperationWrapper(View parentView)
        {
            this.parentView = parentView;
            initViews();
            initListeners();
            initDatas();
        }

        /**
         * 核心初始化方法.
         */
        private void initViews()
        {
            layoutInfiniteProgessBar = (LinearLayout) parentView.findViewById(R.id.common_mall_main_layout_entrance_device_goodslist_infinite_progress_ll);
            // GridView组件实例
            gridview = (ListView) parentView.findViewById(R.id.common_mall_main_layout_entrance_device_devicesGridView);
            if (staticListData == null)
                staticListData = MallGlobal.getMallProviderInstance(c()).getRobotimeMall().getGoodsProvider().getRosterData();
            listAdapter = new DefaultListAdapter(a());
            gridview.setAdapter(listAdapter);
            galeryPics = (Gallery)parentView.findViewById(R.id.common_mall_main_layout_entrance_header_picsGalery);
            galleryAdapter = new PicsGalleryAdapter(a());
            galeryPics.setAdapter(galleryAdapter);
            mDotList = (IndicationDotList) parentView.findViewById(R.id.common_mall_main_layout_entrance_header_index_indication);
        }

        private void initListeners()
        {
            gridview.setOnItemClickListener(new DefaultItemClickListener());
            // 滑动gallery的图片时更新对应指示器的选中样式
            galeryPics.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
                @Override
                public void onItemSelected(AdapterView<?> parent, View v,int position, long id) {
//					// 保存当前被选中的索引
//			    	currentSelectedPicIndex = position;
                    mDotList.setIndex(position);
                }

                @Override
                public void onNothingSelected(AdapterView<?> arg0) {
                    //这里不做响应
                }
            });

            galeryPics.setOnItemClickListener(new AdapterView.OnItemClickListener() {
                @Override
                public void onItemClick(AdapterView<?> partent, View v, int position, long id) {
                }
            });
        }

        private void initDatas()
        {
            Log.d("XXXXXXXXXXXXXX", "initDatas,isHasInit?" + MallGlobal.getMallProviderInstance(c()).getRobotimeMall().getGoodsProvider().isHasInit());

            refreshDatasToUI();
//			// 没有加载过数据才开始加载
//			if (!RobotimeMall.getMallProviderInstance(MainActivity.this)
//					.getRobotimeMall().getGoodsProvider().isHasInit())
//			{
            new GoodsProvider.DataRefreshAsyncTask(a(), MallGlobal.getMallProviderInstance(c()).getRobotimeMall().getGoodsProvider()) {
                @Override
                protected void _showProgessBar()
                {
                    showProgessBar();
                }

                @Override
                protected void _hideProgessBar()
                {
                    hideProgessBar();
                }

                @Override
                protected void _dataLoadSucess()
                {
                    refreshDatasToUI();
                }
            }.execute();
//			}
//			else
//			{
//				refreshDatasToUI();
//			}
        }

        // 显示进度提示
        private void showProgessBar()
        {
            layoutInfiniteProgessBar.setVisibility(View.VISIBLE);
        }

        // 隐藏进度提示
        private void hideProgessBar()
        {
            layoutInfiniteProgessBar.setVisibility(View.GONE);
        }

        /**
         * 刷新UI上的数据显示.
         */
        private void refreshDatasToUI()
        {
            listAdapter.setListData(MallGlobal.getMallProviderInstance(c()).getRobotimeMall().getGoodsProvider().getRosterData());
            features = getFeatures();
            galleryAdapter.setListData(features);
            mDotList.setCount(features.size());
            listAdapter.notifyDataSetChanged();
            galleryAdapter.notifyDataSetChanged();
            Utility.setListViewHeightBasedOnChildren(gridview);
        }

        /**
         * 本类的默认实现：OnItemClickListener实现类.
         *
         * <p>
         * 当AdapterView被单击(触摸屏或者键盘)，则返回的Item单击事件.
         *
         * @author Jack Jiang, 2013-07-24
         * @version 1.0
         */
        private class DefaultItemClickListener implements AdapterView.OnItemClickListener {
            @Override
            public void onItemClick(AdapterView<?> adapterViewWhereTheClickHappened, // The AdapterView where the click happened
                                    View arg1, // The view within the AdapterView that was
                                    // clicked
                                    int position, // The position of the view in the adapter
                                    long arg3 // The row id of the item that was clicked
            ) {
                // 在本例中arg2=arg3
                Device item = (Device) adapterViewWhereTheClickHappened.getItemAtPosition(position);
                // 进入商品详情查看页面
                startActivity(IntentFactory.createGoodDetailActivityIntent(a(), item));
            }
        }

        /**
         * 本类的默认实现：列表适配器实现类.
         *
         * @author Jack Jiang, 2013-07-24
         * @version 1.0
         */
        private class DefaultListAdapter extends AListAdapter2<Device>
        {
            /** 记录选中的ListView的行索引值以备后用（目前是在：单击、长按2类事件中保存了此索引值）. */
            private int selectedListViewIndex = -1;

            public DefaultListAdapter(Activity context) {
                // R.layout.chatting_list_view_bottom_waves_list_item
                super(context, R.layout.common_mall_main_fragment_gridview_item);
            }

            @Override
            // 本方法只在父类AListAdapter的构造方法里被调用一次，所以一定要注意staticListData被实例化的时机
            protected ArrayList<Device> createListData() {
                // 注意：不能使用与AListAdapter里默认的数据模型listData一样的名字哦，否则将错误地引用父类该对象从而导致空指针
                return staticListData;
            }

            @Override
            public View getView(final int position, View convertView, ViewGroup parent)
            {
                // 列表item上的：
                TextView viewText = null;
                // 列表item上的：
                ImageView viewImage = null;
                TextView viewGoodDesc = null;
                TextView viewPriceCurrency = null;
                TextView viewPrice = null;

                // ----------------------------------------------------------------------------------------
                // （1）UI初始化
                // 当的item布局实例已经存在（不在存，意味着这个item刚好从不可见区移到可见区时）
                // ** 根据android的列表ui实现，为了节比资源占用，假如列表有100行而可见区显示5行，那么任何时候
                // ** 这个列表中只会有5个item的UI存在，其它的item都是当被转到可见区时自动把自
                // ** 已的数据实时地更新列UI上，以便查看，也就是说item的UI并不是与后台数据一
                // ** 一对应的，所以正如API文档里说的，convertView并不能确保它总能按你的想法保持不为null
                boolean needCreateItem = (convertView == null);
                // 正在操作的列表行的数据集
                final Device rowData = listData.get(position);
                if (needCreateItem)
                    // 明细item的UI实例化
                    convertView = layoutInflater.inflate(itemResId, null);
                // item里的操作组件实例
                viewText = (TextView) convertView.findViewById(R.id.common_mall_main_layout_entrance_gridview_item_textView);
                viewImage = (ImageView) convertView.findViewById(R.id.common_mall_main_layout_entrance_gridview_item_imageView);
                viewGoodDesc = (TextView) convertView.findViewById(R.id.common_mall_shop_layout_shopcar_good_item_goodDescView);
                viewPriceCurrency = (TextView) convertView.findViewById(R.id.common_mall_shop_layout_shopcar_good_item_priceCurrencyView);
                viewPrice = (TextView) convertView.findViewById(R.id.common_mall_shop_layout_shopcar_good_item_goodPriceView);
                // ----------------------------------------------------------------------------------------
                // （2）增加事件处理器
                // 各操作组件的事件监听器只需要在convertView被实例化时才需要重建（convertView需要被实例化
                // 当然就意味着它上面的所有操作组件都已经重新新建了）
                // ** 关于事件处理器的说明：事件处理器的增加其实可以不这么麻烦，直接每getView一次就给组件new一个处理器，
                // ** 这样做的好处是简单，但显然存在资源浪费（每刷新一次view就新建监听器）。而现在的实现就跟Android的列表
                // ** 实现原理一样，在切换到下一组item前，监听器永远只有一屏item的数量（刷新时只需要即时刷新对应item的数据到
                // ** 它的监听器里），这样就节省了资源开销！
                if (needCreateItem) {
                    //
                }

                // ----------------------------------------------------------------------------------------
                // （3）
                //** TODO Flag的设置代码目前仅作为视觉效果加的，以后这个字段放到数据库里维护则是最佳方式
                viewText.setText(rowData.getDevice_short_name());
                viewImage.setImageResource(Utility.getDefaultGoodPreviewIconRes(rowData.getDevice_short_name()));
                viewGoodDesc.setText(rowData.getDevice_desc());
                viewPriceCurrency.setText(Utility.DEFAULT_CURRENCY_TYPE_NAME);
                viewPrice.setText(rowData.getSale_price());

                return convertView;
            }

            public int getSelectedListViewIndex()
            {
                return selectedListViewIndex;
            }

            public void setSelectedListViewIndex(int selectedListViewIndex) {
                this.selectedListViewIndex = selectedListViewIndex;
//				this.notifyDataSetChanged();
            }
        }

        private ArrayList<Feature> getFeatures() {
            ArrayList<Feature> features = new ArrayList<Feature>();
            for(Device d : staticListData) {
                if(d.getFeature() != null)
                    features.add(d.getFeature());
            }

            return features;
        }


        private class PicsGalleryAdapter extends AListAdapter2<Feature>
        {
            private AsyncBitmapLoader asyncLoader = null;
            /** 记录选中的ListView的行索引值以备后用（目前是在：单击、长按2类事件中保存了此索引值）.*/
            private int selectedListViewIndex = -1;

            public PicsGalleryAdapter(Activity context) {
                // R.layout.chatting_list_view_bottom_waves_list_item
                super(context, R.layout.common_mall_main_fragment_pic_item);
                this.asyncLoader = new AsyncBitmapLoader(MallGlobal.getMallProviderInstance(
                        context).getRobotimeMall().getGoodPicsCachedDirPath());
            }

            @Override
            public View getView(final int position, View convertView, ViewGroup parent) {
                try {
                    ImageView viewImage = null;
                    boolean needCreateItem = (convertView == null);
                    //正在操作的列表行的数据集
                    final Feature rowData = listData.get(position);
                    if (needCreateItem)
                        //明细item的UI实例化
                        convertView = layoutInflater.inflate(itemResId, null);

                    viewImage = (ImageView) convertView.findViewById(R.id.common_mall_main_layout_entrance_pic_item_imageView);
                    if(needCreateItem) {
                    }
//					System.out.println("XXXXXXXXXXXXXXXXXXXXXXXX: " + RobotimeMall.getMallProviderInstance(this.getContext()).getRobotimeMall().GOODS_PIC_HTTP_ROOT_URL());
                    Bitmap bitmap = asyncLoader.loadBitmap(viewImage,
                            MallGlobal.getMallProviderInstance(
                                    this.getContext()).getRobotimeMall().GOODS_PIC_HTTP_ROOT_URL() + rowData.getPic_path(),
                            new AsyncBitmapLoader.ImageCallBack() {
                                @Override
                                public void imageLoad(ImageView imageView, Bitmap bitmap) {
                                    imageView.setImageBitmap(bitmap);

                                    // ## 非常奇怪的一个问题：当网络下载的图片完成时会回调至此，但图片数据明
                                    // ## 明有了却不能刷新显示之，目前为了它能显示就低效地notifyDataSetChanged
                                    // ## 一下吧，以后看看什么方法可以单独刷新（否则每一次都得刷新所有可见区），
                                    // ## 有可能是android的listview机制性问题
                                    PicsGalleryAdapter.this.notifyDataSetChanged();
                                }
                            }
                    );

                    if(bitmap == null) {
                        viewImage.setImageResource(R.drawable.common_mall_default_pic);
                    }
                    else {
                        viewImage.setImageBitmap(bitmap);
                    }
                }
                catch (OutOfMemoryError e) {
                    Log.w(GoodDetailActivity.class.getSimpleName(), "商品图片显示内存不足,建议退出程序并重新进入.", e);
                    Toast.makeText(getContext(), "Product pictures show enough memory, it is recommended to exit the program and re-enter.",Toast.LENGTH_SHORT).show();
                }

                return convertView;
            }

            public int getSelectedListViewIndex() {
                return selectedListViewIndex;
            }

            public void setSelectedListViewIndex(int selectedListViewIndex) {
                this.selectedListViewIndex = selectedListViewIndex;
            }
        }
    }
}
